using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;

/// <summary>
/// 可拖拽的背包格子
/// </summary>
[RequireComponent(typeof(ItemUI))]
public class DragItem : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    /// <summary>
    /// 当前拖拽格子内的物品
    /// </summary>
    private ItemUI currentItemUI;
    /// <summary>
    /// 当前拖拽的格子
    /// </summary>
    private SlotUI currentSlotUI;
    /// <summary>
    /// 拖拽结束的格子
    /// </summary>
    private SlotUI targetSlotUI;

    private void Awake()
    {
        // FIXME: 如果拖拽时报错，就改为在 inspect 窗口中用拖拽脚本的方式赋值
        currentItemUI = GetComponent<ItemUI>();
        currentSlotUI = GetComponentInParent<SlotUI>();
    }
    public void OnBeginDrag(PointerEventData eventData)
    {
        // 拿起物品 记录数据
        InventoryManager.Instance.currentDrag = new InventoryManager.DragData()
        {
            originSlotUI = currentSlotUI,
            originParent = (RectTransform)transform.parent
        };
        // 将当前格子内物品 itemUI 移到最底部的 canvas 上
        // 在 canvasDrag 上移动正在拖拽的物品，避免物品被其他 UI 遮挡
        transform.SetParent(InventoryManager.Instance.dragCanvas.transform, true);
    }

    public void OnDrag(PointerEventData eventData)
    {
        // 物品跟随鼠标移动
        transform.position = eventData.position;
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        // 通过 recttransform 判断格子 放下物品 交换数据
        // 判断鼠标下方是否存在 UI 物体
        if (EventSystem.current.IsPointerOverGameObject())
        {
            if (InventoryManager.Instance.CheckInInventoryUI(eventData.position) ||
                InventoryManager.Instance.CheckInActionUI(eventData.position) ||
                InventoryManager.Instance.CheckInEquipmentUI(eventData.position))
            {
                // 判断鼠标移动进入的物体身上是否包含 SlotUI 脚本
                // 因为开始拖拽时，把起始格子的 itemUI 移动到 dragCanvas 了，起始位置只剩下 slotUI
                // 如果在空格子放下，触碰到空格子的 slotUI
                if (eventData.pointerEnter.gameObject.GetComponent<SlotUI>())
                {
                    targetSlotUI = eventData.pointerEnter.gameObject.GetComponent<SlotUI>();
                    // Debug.Log("EndDrag----" + eventData.pointerEnter.gameObject.name + "----" + targetSlotUI.name);
                }
                // 如果在有物品的格子放下，触碰到格子内的物品 itemUI 的 Image
                else
                {
                    targetSlotUI = eventData.pointerEnter.gameObject.GetComponentInParent<SlotUI>();
                }

                // 位置不同时才交换两个背包格子
                if (targetSlotUI != InventoryManager.Instance.currentDrag.originSlotUI)
                {
                    // WORKFLOW: 判断要交换物品的目标位置执行不同的操作
                    switch (targetSlotUI.slotType)
                    {
                        case SlotType.BAG:
                            // 拖拽武器栏的武器和背包中的蘑菇交换时，不交换
                            if (currentSlotUI.slotType == SlotType.WEAPON &&
                            targetSlotUI.itemUI.Bag.inventoryList[targetSlotUI.itemUI.Index].itemData != null &&
                            targetSlotUI.itemUI.Bag.inventoryList[targetSlotUI.itemUI.Index].itemData.itemType != ItemType.WEAPON)
                            {
                                break;
                            }
                            // 拖拽武器栏的武器和背包中的武器交换时，切换武器
                            SwapItem();
                            break;
                        case SlotType.WEAPON:
                            if (currentItemUI.Bag.inventoryList[currentItemUI.Index].itemData.itemType == ItemType.WEAPON)
                            {
                                SwapItem();
                            }
                            break;
                        case SlotType.ARMOR:
                            if (currentItemUI.Bag.inventoryList[currentItemUI.Index].itemData.itemType == ItemType.ARMOR)
                            {
                                SwapItem();
                            }
                            break;
                        case SlotType.ACTION:
                            if (currentItemUI.Bag.inventoryList[currentItemUI.Index].itemData.itemType == ItemType.USEABLE)
                            {
                                SwapItem();
                            }
                            break;
                        case SlotType.SHIELD:
                            if (currentItemUI.Bag.inventoryList[currentItemUI.Index].itemData.itemType == ItemType.SHIELD)
                            {
                                SwapItem();
                            }
                            break;
                        case SlotType.HELMET:
                            if (currentItemUI.Bag.inventoryList[currentItemUI.Index].itemData.itemType == ItemType.HELMET)
                            {
                                SwapItem();
                            }
                            break;
                        case SlotType.BOOTS:
                            if (currentItemUI.Bag.inventoryList[currentItemUI.Index].itemData.itemType == ItemType.BOOTS)
                            {
                                SwapItem();
                            }
                            break;
                    }
                }

                currentSlotUI.UpdateItemUI();
                targetSlotUI.UpdateItemUI();
            }

            // 移回原来的位置
            transform.SetParent(InventoryManager.Instance.currentDrag.originParent);
            // 确保拖拽结束后的物品位于格子的中心位置
            // itemUI 是拉伸的图片，当拖拽结束时，如果鼠标位置偏离格子中心，itemUI 会产生偏移
            RectTransform t = transform as RectTransform;
            t.offsetMax = -Vector2.one * 4;
            t.offsetMin = Vector2.one * 4;
        }
        // TODO: 在世界坐标生成要丢弃的物品
        else
        {

        }
    }

    /// <summary>
    /// 交换物品
    /// </summary>
    public void SwapItem()
    {
        // 修改数据库链表内对应索引的背包格子内物品
        // 拿到 目标背包格子对应的背包格子内部物品的物品数据库 对应的 目标背包格子对应的背包格子内部物品的索引 下的实际 InventoryItem 物品
        InventoryItem targetItem = targetSlotUI.itemUI.Bag.inventoryList[targetSlotUI.itemUI.Index];
        InventoryItem tempItem = currentSlotUI.itemUI.Bag.inventoryList[currentSlotUI.itemUI.Index];

        bool isSameItem = tempItem.itemData == targetItem.itemData;
        // 增加可堆叠的相同物品的数量
        if (isSameItem && targetItem.itemData.stackable)
        {
            targetSlotUI.itemUI.Bag.inventoryList[targetSlotUI.itemUI.Index] = new InventoryItem()
            {
                itemData = targetItem.itemData,
                inventoryAmount = targetItem.inventoryAmount + tempItem.inventoryAmount
            };

            currentSlotUI.itemUI.Bag.inventoryList[currentSlotUI.itemUI.Index] = new InventoryItem()
            {
                itemData = null,
                inventoryAmount = 0
            };
        }
        else
        {
            currentSlotUI.itemUI.Bag.inventoryList[currentSlotUI.itemUI.Index] = targetItem;
            // 临时的引用变量
            // targetItem = tempItem;
            // 对应链表中的值
            targetSlotUI.itemUI.Bag.inventoryList[targetSlotUI.itemUI.Index] = tempItem;
        }
    }
}
